/**
 * 右键菜单操作功能模块
 * 包含任务块的添加和删除功能
 */

import axios from 'axios'

export class ContextMenuOperations {
  constructor(vueInstance) {
    this.vm = vueInstance
  }

  /**
   * 显示右键菜单
   * @param {Event} event - 鼠标事件
   * @param {Object} item - 任务块项目（可选）
   */
  showContextMenu(event, item) {
    event.preventDefault()
    event.stopPropagation()
    
    this.vm.selectedScheduleItem = item
    this.vm.contextMenuSatelliteId = item ? item.satelliteId : null
    // 如果右键点击的是任务块，使用任务块的起始时间点
    this.vm.contextMenuTimeIndex = item ? item.startDay : null
    this.vm.contextMenuX = event.clientX
    this.vm.contextMenuY = event.clientY
    this.vm.contextMenuVisible = true
    
    // 点击其他地方隐藏菜单
    document.addEventListener('click', this.hideContextMenu.bind(this))
  }

  /**
   * 显示单元格右键菜单
   * @param {Event} event - 鼠标事件
   * @param {string} satelliteId - 卫星ID
   * @param {number} timeIndex - 时间索引
   */
  showCellContextMenu(event, satelliteId, timeIndex) {
    event.preventDefault()
    event.stopPropagation()
    
    this.vm.contextMenuSatelliteId = satelliteId
    this.vm.contextMenuTimeIndex = timeIndex
    this.vm.selectedScheduleItem = null
    this.vm.contextMenuX = event.clientX
    this.vm.contextMenuY = event.clientY
    this.vm.contextMenuVisible = true
    
    // 点击其他地方隐藏菜单
    document.addEventListener('click', this.hideContextMenu.bind(this))
  }

  /**
   * 隐藏右键菜单
   */
  hideContextMenu() {
    this.vm.contextMenuVisible = false
    this.vm.selectedScheduleItem = null
    this.vm.contextMenuSatelliteId = null
    this.vm.contextMenuTimeIndex = null
    document.removeEventListener('click', this.hideContextMenu.bind(this))
  }

  /**
   * 显示任务块选择器
   */
  async showTaskBlockSelector() {
    this.vm.taskBlockSelectorVisible = true
    this.vm.selectedTaskBlock = null
    await this.vm.loadTaskBlocks() // 加载任务块数据
    
    // 只隐藏菜单显示，但保留上下文信息
    this.vm.contextMenuVisible = false
    document.removeEventListener('click', this.hideContextMenu.bind(this))
  }

  /**
   * 关闭任务块选择器
   */
  closeTaskBlockSelector() {
    this.vm.taskBlockSelectorVisible = false
    this.vm.selectedTaskBlock = null
    
    // 清除上下文信息
    this.vm.contextMenuSatelliteId = null
    this.vm.contextMenuTimeIndex = null
    this.vm.selectedScheduleItem = null
  }

  /**
   * 选择任务块
   * @param {Object} taskBlock - 任务块对象
   */
  selectTaskBlock(taskBlock) {
    this.vm.selectedTaskBlock = taskBlock
  }

  /**
   * 应用选择的任务块
   */
  async applySelectedTaskBlock() {
    // 查找对应的卫星
    const targetSatellite = this.vm.allSatellites.find(sat => sat.id === this.vm.contextMenuSatelliteId)
    
    if (!this.vm.selectedTaskBlock) {
      alert('请先选择一个任务块')
      return
    }
    
    if (this.vm.contextMenuSatelliteId === null) {
      alert('无法确定目标卫星，请重新操作')
      return
    }
    
    if (this.vm.contextMenuTimeIndex === null) {
      alert('无法确定添加位置，请重新操作')
      return
    }
    
    if (!targetSatellite) {
      alert('找不到对应的卫星，请重新操作')
      return
    }
    
    // 确定添加位置：如果右键点击的是任务块，在该任务块后面添加；否则在点击位置添加
    let availableStartDay
    
    // 查找右键点击位置是否有任务块
    const clickedTaskBlock = this.vm.scheduleItems.find(item => {
      return item.satelliteId === this.vm.contextMenuSatelliteId &&
             this.vm.contextMenuTimeIndex >= item.startDay &&
             this.vm.contextMenuTimeIndex < item.startDay + item.duration
    })
    
    if (clickedTaskBlock) {
      // 如果点击的是任务块，在该任务块后面插入
      const insertPosition = clickedTaskBlock.startDay + clickedTaskBlock.duration
      availableStartDay = await this.insertTaskBlockAt(
        this.vm.contextMenuSatelliteId,
        insertPosition,
        this.vm.selectedTaskBlock.duration
      )
    } else {
      // 如果点击的是空白区域，在点击位置添加
      availableStartDay = this.vm.findNextAvailableStartDay(
        this.vm.contextMenuSatelliteId, 
        this.vm.contextMenuTimeIndex, 
        this.vm.selectedTaskBlock.duration
      )
    }
    
    // 创建新的任务块项目
    // 自动激活所有天数的设备配置
    let autoActivatedDayConfigs = []
    
    if (this.vm.selectedTaskBlock.requiredDevices && Array.isArray(this.vm.selectedTaskBlock.requiredDevices) && this.vm.selectedTaskBlock.requiredDevices.length > 0) {
      // 如果有 requiredDevices，自动为所有天数激活这些设备
      for (let i = 0; i < this.vm.selectedTaskBlock.duration; i++) {
        autoActivatedDayConfigs.push([...this.vm.selectedTaskBlock.requiredDevices])
      }
    } else if (this.vm.selectedTaskBlock.requiredDevice) {
      // 兼容旧版本：如果只有 requiredDevice
      for (let i = 0; i < this.vm.selectedTaskBlock.duration; i++) {
        autoActivatedDayConfigs.push([this.vm.selectedTaskBlock.requiredDevice])
      }
    } else if (this.vm.selectedTaskBlock.dayConfigs && Array.isArray(this.vm.selectedTaskBlock.dayConfigs)) {
      // 如果有现有的 dayConfigs，使用它们
      autoActivatedDayConfigs = [...this.vm.selectedTaskBlock.dayConfigs]
      // 确保长度匹配
      while (autoActivatedDayConfigs.length < this.vm.selectedTaskBlock.duration) {
        autoActivatedDayConfigs.push([])
      }
    } else {
      // 如果没有任何设备配置，创建空的配置
      for (let i = 0; i < this.vm.selectedTaskBlock.duration; i++) {
        autoActivatedDayConfigs.push([])
      }
    }
    
    // 设置标志防止watcher重复保存
    this.vm.isUpdatingScheduleItems = true
    
    const newScheduleItem = {
      id: Date.now() // 使用时间戳作为临时ID
    }
    // 计算实际起始日期（本地时区）
    const baseDate = this.vm.parseYMDLocal(this.vm.startDate)
    const actualStartDate = new Date(baseDate)
    actualStartDate.setDate(baseDate.getDate() + availableStartDay)

    this.vm.scheduleItems.push({
      ...newScheduleItem,
      title: this.vm.selectedTaskBlock.name,
      satelliteId: this.vm.contextMenuSatelliteId,
      satelliteName: targetSatellite.name,
      startDay: availableStartDay,
      duration: this.vm.selectedTaskBlock.duration,
      color: this.vm.selectedTaskBlock.color,
      type: 'task',
      requiredDevice: this.vm.selectedTaskBlock.requiredDevice,
      requiredDevices: this.vm.selectedTaskBlock.requiredDevices || [],
      dayConfigs: autoActivatedDayConfigs, // 使用自动激活的设备配置
      actualStartDate: this.vm.toYMDLocal(actualStartDate) // 记录实际起始日期（本地）
    })
    
    // 设置排程数据状态
    this.vm.hasScheduleData = true
    
    // 重置标志（已移除自动保存）
    this.vm.isUpdatingScheduleItems = false
    
    // 确保显示天数足够包含新添加的任务块
    this.vm.ensureSufficientDays()
    
    // 立即进行时间冲突检测和修复
    this.vm.validateAndFixOverlaps(this.vm.contextMenuSatelliteId)
    
    // 验证没有重叠（开发验证）
    this.vm.validateNoOverlap(this.vm.contextMenuSatelliteId)
    
    // 进行设备冲突检测
    const conflicts = this.vm.detectDeviceConflicts()
    if (conflicts.length > 0) {
      this.vm.markConflictingTasks(conflicts)
    } else {
      this.vm.clearConflictMarks()
    }
    
    // 强制更新视图
    this.vm.$forceUpdate()
    
    // 关闭选择器
    this.closeTaskBlockSelector()
  }

  /**
   * 在指定位置插入任务块，推移后面的任务块
   * @param {string} satelliteId - 卫星ID
   * @param {number} insertPosition - 插入位置
   * @param {number} duration - 任务块持续时间
   * @returns {number} 实际插入位置
   */
  async insertTaskBlockAt(satelliteId, insertPosition, duration) {
    const satelliteItems = this.vm.scheduleItems.filter(item => item.satelliteId === satelliteId)
    
    // 找到所有在插入位置之后的任务块
    const itemsToMove = satelliteItems.filter(item => item.startDay >= insertPosition)
    
    if (itemsToMove.length === 0) {
      // 如果后面没有任务块，直接在插入位置添加
      return insertPosition
    }
    
    // 将后面的任务块向后推移，并同步实际起始日期（本地）
    itemsToMove.forEach(item => {
      item.startDay += duration
      const baseDate = this.vm.parseYMDLocal(this.vm.startDate)
      const newActualStart = new Date(baseDate)
      newActualStart.setDate(baseDate.getDate() + item.startDay)
      item.actualStartDate = this.vm.toYMDLocal(newActualStart)
    })
    
    return insertPosition
  }

  /**
   * 删除任务块
   */
  async deleteScheduleItem() {
    let itemToDelete = null
    
    // 如果有选中的任务块，优先删除选中的任务块
    if (this.vm.selectedScheduleItem) {
      itemToDelete = this.vm.selectedScheduleItem
    } else if (this.vm.contextMenuSatelliteId !== null && this.vm.contextMenuTimeIndex !== null) {
      // 如果没有选中的任务块，但有右键菜单的上下文信息，查找该位置的任务块
      const itemsAtPosition = this.vm.scheduleItems.filter(item => {
        return item.satelliteId === this.vm.contextMenuSatelliteId && 
               this.vm.contextMenuTimeIndex >= item.startDay && 
               this.vm.contextMenuTimeIndex < item.startDay + item.duration
      })
      
      // 如果有多个任务块重叠，选择最后添加的（ID最大的）
      if (itemsAtPosition.length > 0) {
        itemToDelete = itemsAtPosition.reduce((latest, current) => {
          return current.id > latest.id ? current : latest
        })
      }
    }
    
    if (itemToDelete && confirm(`确定要删除任务块"${itemToDelete.title}"吗？`)) {
      const itemIndex = this.vm.scheduleItems.findIndex(item => item.id === itemToDelete.id)
      if (itemIndex !== -1) {
        const removedItem = this.vm.scheduleItems[itemIndex]
        const satelliteId = removedItem.satelliteId
        
        // 检查删除后该卫星是否还有其他任务块
        const remainingSatelliteItems = this.vm.scheduleItems.filter(item => 
          item.satelliteId === satelliteId && item.id !== removedItem.id
        )
        
        // 设置标志防止watcher重复保存
        this.vm.isUpdatingScheduleItems = true
        
        this.vm.scheduleItems.splice(itemIndex, 1)
        
        // 重置标志
        this.vm.isUpdatingScheduleItems = false
        
        // 如果该卫星没有其他任务块了，删除数据库中的整条记录
        if (remainingSatelliteItems.length === 0) {
          await this.deleteSatelliteScheduleRecord(satelliteId)
        }
        
        // 如果没有任务块了，更新状态
        if (this.vm.scheduleItems.length === 0) {
          this.vm.hasScheduleData = false
          this.vm.clearConflictMarks()
        } else {
          // 删除任务块后重新检测冲突
          const conflicts = this.vm.detectDeviceConflicts()
          if (conflicts.length > 0) {
            this.vm.markConflictingTasks(conflicts)
          } else {
            this.vm.clearConflictMarks()
          }
        }
      }
    } else if (!itemToDelete) {
      alert('未找到要删除的任务块')
    }
    this.hideContextMenu()
  }

  /**
   * 删除卫星排程记录
   * @param {string} satelliteId - 卫星ID
   */
  async deleteSatelliteScheduleRecord(satelliteId) {
    try {
      // 调用后端API删除整条卫星排程记录
      const response = await axios.delete(`/api/scheduling/satellite-schedules/delete_by_satellite/${satelliteId}/`)
      
      if (response.data && !response.data.success) {
        alert(`删除卫星排程记录失败`)
      }
    } catch (error) {
      alert(`删除卫星排程记录失败: ${error.response ? error.response.data.error || error.response.statusText : error.message}`)
    }
  }

  /**
   * 检查右键菜单位置是否有任务块
   * @returns {boolean} 是否有任务块
   */
  hasTaskBlockAtContextPosition() {
    // 如果有选中的任务块，返回true
    if (this.vm.selectedScheduleItem) {
      return true
    }
    
    // 如果没有选中的任务块但有上下文信息，查找该位置是否有任务块
    if (this.vm.contextMenuSatelliteId !== null && this.vm.contextMenuTimeIndex !== null) {
      return this.vm.scheduleItems.some(item => {
        return item.satelliteId === this.vm.contextMenuSatelliteId && 
               this.vm.contextMenuTimeIndex >= item.startDay && 
               this.vm.contextMenuTimeIndex < item.startDay + item.duration
      })
    }
    
    return false
  }
}

export default ContextMenuOperations